View Javadoc

1   /*
2    * Copyright 2001-2004 The Apache Software Foundation.
3    * 
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    * 
8    *      http://www.apache.org/licenses/LICENSE-2.0
9    * 
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS,
12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   * See the License for the specific language governing permissions and
14   * limitations under the License.
15   */
16  package org.apache.geronimo.ews.jaxrpcmapping;
17  
18  import com.sun.java.xml.ns.j2Ee.ExceptionMappingType;
19  import com.sun.java.xml.ns.j2Ee.JavaWsdlMappingDocument;
20  import com.sun.java.xml.ns.j2Ee.JavaWsdlMappingType;
21  import com.sun.java.xml.ns.j2Ee.JavaXmlTypeMappingType;
22  import com.sun.java.xml.ns.j2Ee.MethodParamPartsMappingType;
23  import com.sun.java.xml.ns.j2Ee.PackageMappingType;
24  import com.sun.java.xml.ns.j2Ee.PortMappingType;
25  import com.sun.java.xml.ns.j2Ee.ServiceEndpointInterfaceMappingType;
26  import com.sun.java.xml.ns.j2Ee.ServiceEndpointMethodMappingType;
27  import com.sun.java.xml.ns.j2Ee.ServiceInterfaceMappingType;
28  import com.sun.java.xml.ns.j2Ee.WsdlReturnValueMappingType;
29  import com.sun.java.xml.ns.j2Ee.XsdQNameType;
30  import org.apache.axis.wsdl.symbolTable.BindingEntry;
31  import org.apache.axis.wsdl.symbolTable.PortTypeEntry;
32  import org.apache.axis.wsdl.symbolTable.ServiceEntry;
33  import org.apache.geronimo.ews.ws4j2ee.toWs.GenerationFault;
34  import org.apache.xmlbeans.XmlException;
35  
36  import javax.wsdl.Binding;
37  import javax.wsdl.Operation;
38  import javax.wsdl.Port;
39  import javax.wsdl.PortType;
40  import javax.xml.namespace.QName;
41  import java.io.FileInputStream;
42  import java.io.FileNotFoundException;
43  import java.io.IOException;
44  import java.io.InputStream;
45  
46  /***
47   * @author Ias (iasandcb@tmax.co.kr)
48   */
49  public class XMLBeansJaxRpcMapper implements JaxRpcMapper {
50  
51      private JavaWsdlMappingType mapping;
52      
53      private boolean wrappedElement = false;
54  
55      public void loadMappingFromInputStream(InputStream is) throws GenerationFault {
56          try {
57              JavaWsdlMappingDocument mappingdoc = JavaWsdlMappingDocument.Factory.parse(is);
58              mapping = mappingdoc.getJavaWsdlMapping();
59          } catch (XmlException e) {
60              e.printStackTrace();
61              throw GenerationFault.createGenerationFault(e);
62          } catch (IOException e) {
63              e.printStackTrace();
64              throw GenerationFault.createGenerationFault(e);
65          }
66          wrappedElement = checkWrappedElemente();
67      }
68  
69      public void loadMappingFromDir(String path) throws GenerationFault {
70          try {
71              java.io.InputStream fis = new FileInputStream(path);
72              JavaWsdlMappingDocument mappingdoc = JavaWsdlMappingDocument.Factory.parse(fis);
73              mapping = mappingdoc.getJavaWsdlMapping();
74          } catch (FileNotFoundException e2) {
75              e2.printStackTrace();
76              throw GenerationFault.createGenerationFault(e2);
77          } catch (IOException e) {
78              e.printStackTrace();
79              throw GenerationFault.createGenerationFault(e);
80          } catch (XmlException e2) {
81              e2.printStackTrace();
82              throw GenerationFault.createGenerationFault(e2);
83          }
84          wrappedElement = checkWrappedElemente();
85      }
86  
87      public int getPackageMappingCount() {
88          PackageMappingType[] packagemapping = mapping.getPackageMappingArray();
89          return</strong> packagemapping.length;
90      }
91  
92      public String getPackageMappingClassName(int index) {
93          PackageMappingType[] packagemapping = mapping.getPackageMappingArray();
94          return</strong> packagemapping[index].getPackageType().getStringValue();
95      }
96  
97      public String getPackageMappingURI(int index) {
98          PackageMappingType[] packagemapping = mapping.getPackageMappingArray();
99          return</strong> packagemapping[index].getNamespaceURI().getStringValue();
100     }
101 
102     /***
103      * @return Returns the mapping.
104      */
105     public JavaWsdlMappingType getMapping() {
106         return mapping;
107     }
108 
109     public String getJavaType(QName typeQName) {
110         if (mapping == null) {
111             return null;
112         }
113         JavaXmlTypeMappingType[] typeList = mapping.getJavaXmlTypeMappingArray();
114         for (int i = 0; i < typeList.length; i++) {
115             JavaXmlTypeMappingType typeMapping = typeList[i];
116             XsdQNameType rootType = typeMapping.getRootTypeQname();
117             if (rootType == null) {
118                 String mappedAnonymousTypeName = typeMapping.getAnonymousTypeQname().getStringValue();
119                 String localPart = typeQName.getLocalPart();
120                 String revisitedTypeQName = typeQName.getNamespaceURI() + ":" + localPart;
121                 if (mappedAnonymousTypeName.equals(revisitedTypeQName)) {
122                     //TODO this is a quick fix there should be a better way to do this 
123                     return J2eeUtils.jni2javaName(typeMapping.getJavaType().getStringValue());
124                 }
125             } else {
126                 QName typeName = rootType.getQNameValue();
127                 if (typeQName.equals(typeName)) {
128                     String className = typeMapping.getJavaType().getStringValue();
129                     //TODO this is a quick fix there should be a better way to do this
130                     return J2eeUtils.jni2javaName(className);
131                 }
132             }
133         }
134         return null;
135     }
136 
137     public String getExceptionType(QName messageQName) {
138         if (mapping == null) {
139             return null;
140         }
141         ExceptionMappingType[] exceptionMappingList = mapping.getExceptionMappingArray();
142         for (int j = 0; j < exceptionMappingList.length; j++) {
143             ExceptionMappingType exceptionMapping = exceptionMappingList[j];
144             QName name = exceptionMapping.getWsdlMessage().getQNameValue();
145             if (messageQName.equals(name)) {
146                 return exceptionMapping.getExceptionType().getStringValue();
147             }
148         }
149         return null;
150     }
151 
152     public String getPortName(Port port) {
153         if (mapping == null) {
154             return null;
155         }
156         ServiceInterfaceMappingType[] serviceList = mapping.getServiceInterfaceMappingArray();
157         String portName = port.getName();
158         for (int i = 0; i < serviceList.length; i++) {
159             PortMappingType[] portList = serviceList[i].getPortMappingArray();
160             for (int j = 0; j < portList.length; j++) {
161                 PortMappingType portMapping = portList[j];
162                 String mappedPortName = portMapping.getPortName().getStringValue();
163                 if (portName.equals(mappedPortName)) {
164                     String javaPortName = portMapping.getJavaPortName().getStringValue();
165                     return javaPortName;
166                 }
167             }
168         }
169         return null;
170     }
171 
172     public String getServiceInterfaceName(ServiceEntry entry) {
173         if (mapping == null) {
174             return null;
175         }
176         ServiceInterfaceMappingType[] serviceList = mapping.getServiceInterfaceMappingArray();
177         QName entryQName = entry.getQName();
178         for (int i = 0; i < serviceList.length; i++) {
179             QName wsdlServiceName = serviceList[i].getWsdlServiceName().getQNameValue();
180             if (entryQName.equals(wsdlServiceName)) {
181                 String serviceInterfaceName = serviceList[i].getServiceInterface().getStringValue();
182                 return serviceInterfaceName;
183             }
184         }
185         return null;
186     }
187 
188     public String getServiceEndpointInterfaceName(PortTypeEntry ptEntry, BindingEntry bEntry) {
189         if (mapping == null) {
190             return null;
191         }
192         ServiceEndpointInterfaceMappingType[] serviceList = mapping.getServiceEndpointInterfaceMappingArray();
193         Binding binding = bEntry.getBinding();
194         PortType portType = ptEntry.getPortType();
195         QName bindingQName = binding.getQName();
196         QName portTypeQName = portType.getQName();
197         for (int i = 0; i < serviceList.length; i++) {
198             QName wsdlBinging = serviceList[i].getWsdlBinding().getQNameValue();
199             QName wsdlPortType = serviceList[i].getWsdlPortType().getQNameValue();
200             if ((bindingQName.equals(wsdlBinging)) && (portTypeQName.equals(wsdlPortType))) {
201                 String endpointServiceName =
202                         serviceList[i].getServiceEndpointInterface().getStringValue();
203                 return endpointServiceName;
204             }
205         }
206         return null;
207     }
208 
209     /***
210      * @param entry
211      * @param operation
212      * @param i
213      * @return
214      */
215     public String getJavaMethodParamType(BindingEntry bEntry, Operation operation, int position) {
216         if (mapping == null) {
217             return null;
218         }
219         ServiceEndpointInterfaceMappingType[] serviceList = mapping.getServiceEndpointInterfaceMappingArray();
220         Binding binding = bEntry.getBinding();
221         QName bindingQName = binding.getQName();
222         PortType portType = binding.getPortType();
223         QName portTypeQName = portType.getQName();
224         for (int i = 0; i < serviceList.length; i++) {
225             QName wsdlBinging = serviceList[i].getWsdlBinding().getQNameValue();
226             QName wsdlPortType = serviceList[i].getWsdlPortType().getQNameValue();
227             if ((bindingQName.equals(wsdlBinging)) && (portTypeQName.equals(wsdlPortType))) {
228                 ServiceEndpointMethodMappingType[] methodList = serviceList[i].getServiceEndpointMethodMappingArray();
229                 String operationName = operation.getName();
230                 for (int k = 0; k < methodList.length; k++) {
231                     ServiceEndpointMethodMappingType methodMapping = methodList[k];
232                     String mappedOperationName = methodMapping.getWsdlOperation().getStringValue();
233                     if (operationName.equals(mappedOperationName)) {
234                         MethodParamPartsMappingType[] paramList = methodMapping.getMethodParamPartsMappingArray();
235                         for (int m = 0; m < paramList.length; m++) {
236                             MethodParamPartsMappingType paramPart = paramList[m];
237                             if (paramPart.getParamPosition().getBigIntegerValue().intValue() == position) {
238                                 //TODO this is a quick fix there should be a better way to do this
239                                 return J2eeUtils.jni2javaName(paramPart.getParamType().getStringValue());
240                             }
241                         }
242                     }
243                 }
244             }
245         }
246         return null;
247     }
248 
249     public boolean checkWrappedElemente() {
250         if (mapping == null) {
251             return false;
252         }
253         ServiceEndpointInterfaceMappingType[] serviceList = mapping.getServiceEndpointInterfaceMappingArray();
254         for (int i = 0; i < serviceList.length; i++) {
255             ServiceEndpointMethodMappingType[] methodList = serviceList[i].getServiceEndpointMethodMappingArray();
256             for (int k = 0; k < methodList.length; k++) {
257                 ServiceEndpointMethodMappingType methodMapping = methodList[k];
258                 if (methodMapping.getWrappedElement() != null) {
259                     // do use wrapped style
260                     return true;
261                 }
262             }
263         }
264         return false;
265     }
266     /***
267      * @param entry
268      * @param operation
269      * @return
270      */
271     public String getJavaMethodReturnType(BindingEntry bEntry, Operation operation) {
272         if (mapping == null) {
273             return null;
274         }
275         ServiceEndpointInterfaceMappingType[] serviceList = mapping.getServiceEndpointInterfaceMappingArray();
276         Binding binding = bEntry.getBinding();
277         QName bindingQName = binding.getQName();
278         PortType portType = binding.getPortType();
279         QName portTypeQName = portType.getQName();
280         for (int i = 0; i < serviceList.length; i++) {
281             QName wsdlBinging = serviceList[i].getWsdlBinding().getQNameValue();
282             QName wsdlPortType = serviceList[i].getWsdlPortType().getQNameValue();
283             if ((bindingQName.equals(wsdlBinging)) && (portTypeQName.equals(wsdlPortType))) {
284                 ServiceEndpointMethodMappingType[] methodList = serviceList[i].getServiceEndpointMethodMappingArray();
285                 String operationName = operation.getName();
286                 for (int k = 0; k < methodList.length; k++) {
287                     ServiceEndpointMethodMappingType methodMapping = methodList[k];
288                     String mappedOperationName = methodMapping.getWsdlOperation().getStringValue();
289                     if (operationName.equals(mappedOperationName)) {
290                         WsdlReturnValueMappingType returnValueMapping =
291                                 methodMapping.getWsdlReturnValueMapping();
292                         if (returnValueMapping != null) {
293                             //TODO this is a quick fix there should be a better way to do this
294                             return J2eeUtils.jni2javaName(returnValueMapping.getMethodReturnValue().getStringValue());
295                         }
296                     }
297                 }
298             }
299         }
300         return null;
301     }
302 
303     /***
304      * @param entry
305      * @param operation
306      * @return
307      */
308     public String getJavaMethodName(BindingEntry bEntry, Operation operation) {
309         if (mapping == null) {
310             return null;
311         }
312         ServiceEndpointInterfaceMappingType[] serviceList = mapping.getServiceEndpointInterfaceMappingArray();
313         Binding binding = bEntry.getBinding();
314         QName bindingQName = binding.getQName();
315         PortType portType = binding.getPortType();
316         QName portTypeQName = portType.getQName();
317         for (int i = 0; i < serviceList.length; i++) {
318             QName wsdlBinging = serviceList[i].getWsdlBinding().getQNameValue();
319             QName wsdlPortType = serviceList[i].getWsdlPortType().getQNameValue();
320             if ((bindingQName.equals(wsdlBinging)) && (portTypeQName.equals(wsdlPortType))) {
321                 ServiceEndpointMethodMappingType[] methodList = serviceList[i].getServiceEndpointMethodMappingArray();
322                 String operationName = operation.getName();
323                 for (int k = 0; k < methodList.length; k++) {
324                     ServiceEndpointMethodMappingType methodMapping = methodList[k];
325                     String mappedOperationName = methodMapping.getWsdlOperation().getStringValue();
326                     if (operationName.equals(mappedOperationName)) {
327                         return methodMapping.getJavaMethodName().getStringValue();
328                     }
329                 }
330             }
331         }
332         return null;
333     }
334 
335     /* (non-Javadoc)
336      * @see org.apache.geronimo.ews.jaxrpcmapping.JaxRpcMapper#hasWrappedElement()
337      */
338     public boolean hasWrappedElement() {
339         return wrappedElement;
340     }
341 }